# -*- coding:utf-8 -*-

"""
商家黑名单DAO
"""

from sqlalchemy import select, update, delete
from sqlalchemy.ext.asyncio import AsyncSession

from module_admin.entity.do.seller_blacklist_do import SellerBlacklist


class SellerBlacklistDao:
    """商家黑名单数据访问层"""
    
    @classmethod
    async def get_list(cls, db: AsyncSession, query_dict: dict = None, user_id: int = None):
        """
        获取商家黑名单列表（按用户隔离）
        
        Args:
            db: 数据库会话
            query_dict: 查询条件字典
            user_id: 用户ID，如果提供则只获取该用户的黑名单
        """
        query = select(SellerBlacklist).where(SellerBlacklist.del_flag == '0')
        
        # ✅ 用户隔离：只获取当前用户的黑名单
        if user_id is not None:
            query = query.where(SellerBlacklist.create_by == user_id)
        
        # 搜索条件
        if query_dict:
            if seller_id := query_dict.get('seller_id'):
                query = query.where(SellerBlacklist.seller_id.like(f'%{seller_id}%'))
            if seller_nick := query_dict.get('seller_nick'):
                query = query.where(SellerBlacklist.seller_nick.like(f'%{seller_nick}%'))
        
        query = query.order_by(SellerBlacklist.create_time.desc())
        result = await db.execute(query)
        return result.scalars().all()
    
    @classmethod
    async def get_by_id(cls, db: AsyncSession, blacklist_id: int):
        """
        根据ID获取商家黑名单
        """
        query = select(SellerBlacklist).where(
            SellerBlacklist.id == blacklist_id,
            SellerBlacklist.del_flag == '0'
        )
        result = await db.execute(query)
        return result.scalar_one_or_none()
    
    @classmethod
    async def add(cls, db: AsyncSession, blacklist: SellerBlacklist):
        """
        新增商家黑名单
        """
        db.add(blacklist)
        await db.flush()
        return blacklist
    
    @classmethod
    async def update(cls, db: AsyncSession, blacklist_id: int, update_data: dict):
        """
        更新商家黑名单
        """
        query = update(SellerBlacklist).where(
            SellerBlacklist.id == blacklist_id,
            SellerBlacklist.del_flag == '0'
        ).values(**update_data)
        await db.execute(query)
    
    @classmethod
    async def delete(cls, db: AsyncSession, blacklist_id: int):
        """
        删除商家黑名单（软删除）
        """
        query = update(SellerBlacklist).where(
            SellerBlacklist.id == blacklist_id
        ).values(del_flag='2')
        await db.execute(query)
    
    @classmethod
    async def check_exists(cls, db: AsyncSession, seller_id: str = None, seller_nick: str = None, user_id: int = None):
        """
        检查商家是否已在黑名单（按用户隔离）
        
        ✅ 逻辑：如果 seller_id 或 seller_nick 任意一个匹配就认为已存在（OR关系）
        这样可以避免重复添加：
        - 如果已有 seller_id=1 的记录，再添加 seller_id=1 或 seller_nick=xxx 的记录会被检测到
        - 如果已有 seller_nick="严选" 的记录，再添加 seller_nick="爱回收严选深圳仓" 的记录会被检测到（因为"严选"在"爱回收严选深圳仓"中）
        
        Args:
            db: 数据库会话
            seller_id: 卖家ID
            seller_nick: 卖家昵称
            user_id: 用户ID，如果提供则只检查该用户的黑名单
        """
        from sqlalchemy import or_
        
        query = select(SellerBlacklist).where(SellerBlacklist.del_flag == '0')
        
        # ✅ 用户隔离：只检查当前用户的黑名单
        if user_id is not None:
            query = query.where(SellerBlacklist.create_by == user_id)
        
        conditions = []
        if seller_id:
            conditions.append(SellerBlacklist.seller_id == seller_id)
        if seller_nick:
            # ✅ seller_nick可以是包含匹配或完整匹配
            # 检查：1. 黑名单中的seller_nick是否在新seller_nick中（包含匹配）
            #       2. 新seller_nick是否在黑名单中的seller_nick中（反向包含匹配）
            #       3. 完全相等（完整匹配）
            # 注意：SQL中LIKE '%xxx%' 可以匹配包含，但这里需要双向匹配
            # 简化：先检查完全匹配和正向包含，反向包含需要在应用层处理
            conditions.append(
                or_(
                    SellerBlacklist.seller_nick == seller_nick,  # 完整匹配
                    SellerBlacklist.seller_nick.like(f'%{seller_nick}%'),  # 黑名单昵称包含新昵称（较少见）
                    SellerBlacklist.seller_nick.in_([seller_nick])  # 等同于 ==
                )
            )
        
        if conditions:
            query = query.where(or_(*conditions))
        
        result = await db.execute(query)
        existing = result.scalars().all()
        
        # ✅ 对于seller_nick，还需要检查反向包含（新昵称中包含黑名单昵称）
        if seller_nick and existing:
            for item in existing:
                if item.seller_nick and seller_nick:
                    if item.seller_nick in seller_nick:
                        return True
        
        return len(existing) > 0

